home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / unix / volume11 / jove.pch / part03 < prev    next >
Encoding:
Internet Message Format  |  1987-09-15  |  52.7 KB

  1. Subject:  v11i047:  Jove upgrade kit, Part03/04
  2. Newsgroups: comp.sources.unix
  3. Sender: sources
  4. Approved: rs@uunet.UU.NET
  5.  
  6. Submitted-by: Jonathan Payne  <jpayne@cs.rochester.edu>
  7. Posting-number: Volume 11, Issue 47
  8. Archive-name: jove.pch/Part03
  9.  
  10. #! /bin/sh
  11. # This is a shell archive.  Remove anything before this line, then unpack
  12. # it by saving it into a file and typing "sh file".  To overwrite existing
  13. # files, type "sh file -c".  You can also feed this as standard input via
  14. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  15. # will see the following message at the end:
  16. #        "End of archive 3 (of 4)."
  17. # Contents:  jove.pch.3
  18. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  19. if test -f 'jove.pch.3' -a "${1}" != "-c" ; then 
  20.   echo shar: Will not clobber existing file \"'jove.pch.3'\"
  21. else
  22. echo shar: Extracting \"'jove.pch.3'\" \(50121 characters\)
  23. sed "s/^X//" >'jove.pch.3' <<'END_OF_FILE'
  24. Xdiff -c ojove/jove.h jove/jove.h
  25. X*** ojove/jove.h    Thu Jul 16 09:14:38 1987
  26. X--- jove/jove.h    Fri Jul 10 09:25:51 1987
  27. X***************
  28. X*** 57,71 ****
  29. X  #define FORWARD        1
  30. X  #define BACKWARD    -1
  31. X  
  32. X! #define CTL(c)        ('c' & 037)
  33. X! #define META(c)        ('c' | 0200)
  34. X  #define RUBOUT        '\177'
  35. X! #define LF        CTL(J)
  36. X! #define CR        CTL(M)
  37. X! #define BS        CTL(H)
  38. X  #define ESC        '\033'
  39. X  
  40. X- #define DoTimes(f, n)    exp_p = YES, exp = n, f
  41. X  #define HALF(wp)    ((wp->w_height - 1) / 2)
  42. X  #define IsModified(b)    (b->b_modified)
  43. X  #define SIZE(wp)    (wp->w_height - 1)
  44. X--- 57,70 ----
  45. X  #define FORWARD        1
  46. X  #define BACKWARD    -1
  47. X  
  48. X! #define CTL(c)        (c & 037)
  49. X! #define META(c)        (c | 0200)
  50. X  #define RUBOUT        '\177'
  51. X! #define LF        CTL('J')
  52. X! #define CR        CTL('M')
  53. X! #define BS        CTL('H')
  54. X  #define ESC        '\033'
  55. X  
  56. X  #define HALF(wp)    ((wp->w_height - 1) / 2)
  57. X  #define IsModified(b)    (b->b_modified)
  58. X  #define SIZE(wp)    (wp->w_height - 1)
  59. X***************
  60. X*** 81,86 ****
  61. X--- 80,86 ----
  62. X  #define lastp(line)    (line == curbuf->b_last)
  63. X  #define makedirty(line)    line->l_dline |= DIRTY
  64. X  #define one_windp()    (fwind->w_next == fwind)
  65. X+ #define CharUpcase(c)    (CaseEquiv[c])
  66. X  
  67. X  extern int    OkayAbort,    /* okay to abort redisplay */
  68. X          BufSize;
  69. X***************
  70. X*** 121,126 ****
  71. X--- 121,127 ----
  72. X  #define SetMajor(x)    ((curbuf->b_major = x), UpdModLine++)
  73. X  
  74. X  extern char    CharTable[NMAJORS][128];
  75. X+ extern char    CaseEquiv[128];
  76. X  
  77. X  /* setjmp/longjmp args for DoKeys() mainjmp */
  78. X  #define FIRSTCALL    0
  79. X***************
  80. X*** 192,213 ****
  81. X      Process    *p_next;
  82. X  #ifdef PIPEPROCS
  83. X      int    p_toproc,    /* read p_fromproc and write p_toproc */
  84. X!         p_portpid,    /* Pid of child (the portsrv) */
  85. X!         p_pid;        /* Pid of real child i.e. not portsrv */
  86. X  #else
  87. X!     int    p_fd,        /* File descriptor of ptyp? opened r/w */
  88. X          p_pid;        /* pid of child (the shell) */
  89. X  #endif
  90. X!     Buffer    *p_buffer;    /* Add output to end of this buffer */
  91. X      char    *p_name;    /* ... */
  92. X      char    p_state,    /* State */
  93. X          p_howdied,    /* Killed? or Exited? */
  94. X!         p_reason,    /* If signaled, p_reason is the signal; else
  95. X                     it is the the exit code */
  96. X!         p_eof;        /* Received EOF, so can be free'd up */
  97. X!     Mark    *p_mark;    /* Where output left us. */
  98. X      data_obj
  99. X!         *p_cmd;        /* Command to call when process dies */
  100. X  };
  101. X  #endif IPROCS
  102. X  
  103. X--- 193,213 ----
  104. X      Process    *p_next;
  105. X  #ifdef PIPEPROCS
  106. X      int    p_toproc,    /* read p_fromproc and write p_toproc */
  107. X!         p_portpid,    /* pid of child (the portsrv) */
  108. X!         p_pid;        /* pid of real child i.e. not portsrv */
  109. X  #else
  110. X!     int    p_fd,        /* file descriptor of pty? opened r/w */
  111. X          p_pid;        /* pid of child (the shell) */
  112. X  #endif
  113. X!     Buffer    *p_buffer;    /* add output to end of this buffer */
  114. X      char    *p_name;    /* ... */
  115. X      char    p_state,    /* State */
  116. X          p_howdied,    /* Killed? or Exited? */
  117. X!         p_reason;    /* If signaled, p_reason is the signal; else
  118. X                     it is the the exit code */
  119. X!     Mark    *p_mark;    /* where output left us */
  120. X      data_obj
  121. X!         *p_cmd;        /* command to call when process dies */
  122. X  };
  123. X  #endif IPROCS
  124. X  
  125. X***************
  126. X*** 242,249 ****
  127. X      Line    *m_line;
  128. X      int    m_char;
  129. X      Mark    *m_next;    /* list of marks */
  130. X! #define FLOATER    1
  131. X!     char    m_floater;    /* FLOATERing mark? */
  132. X  };
  133. X  
  134. X  struct buffer {
  135. X--- 242,251 ----
  136. X      Line    *m_line;
  137. X      int    m_char;
  138. X      Mark    *m_next;    /* list of marks */
  139. X! #define M_FIXED        00
  140. X! #define M_FLOATER    01
  141. X! #define M_BIG_DELETE    02
  142. X!     char    m_flags;    /* FLOATERing mark? */
  143. X  };
  144. X  
  145. X  struct buffer {
  146. X***************
  147. X*** 380,387 ****
  148. X      ScrollStep,        /* how should we scroll */
  149. X      WtOnMk,            /* write files on compile-it command */
  150. X      EndWNewline,        /* end files with a blank line */
  151. X!     MarkThresh,        /* moves greater than MarkThresh
  152. X!                    will SetMark */
  153. X      PDelay,            /* paren flash delay in tenths of a second */
  154. X      CIndIncrmt,        /* how much each indentation level pushes
  155. X                     over in C mode */
  156. X--- 382,388 ----
  157. X      ScrollStep,        /* how should we scroll */
  158. X      WtOnMk,            /* write files on compile-it command */
  159. X      EndWNewline,        /* end files with a blank line */
  160. X!     MarkThresh,        /* moves greater than MarkThresh will SetMark */
  161. X      PDelay,            /* paren flash delay in tenths of a second */
  162. X      CIndIncrmt,        /* how much each indentation level pushes
  163. X                     over in C mode */
  164. X***************
  165. X*** 408,413 ****
  166. X--- 409,415 ----
  167. X      SExitChar,        /* type this to stop i-search */
  168. X  #endif
  169. X      IntChar,        /* ttysets this to generate QUIT */
  170. X+     DoEVexpand,        /* treat $foo as environment variable */
  171. X      EWSize;            /* size to make the error window */
  172. X  
  173. X  extern char
  174. X***************
  175. X*** 427,435 ****
  176. X      Shell[128];        /* shell to use */
  177. X  
  178. X  extern int
  179. X-     exp,        /* argument count */
  180. X-     exp_p,        /* argument count is supplied */
  181. X- 
  182. X      TOabort,    /* flag set by Typeout() */
  183. X      io,        /* file descriptor for reading and writing files */
  184. X      errormsg,    /* last message was an error message
  185. X--- 429,434 ----
  186. X***************
  187. X*** 539,544 ****
  188. X--- 538,546 ----
  189. X      *tgoto(),
  190. X      *pr_name(),
  191. X      *sprint(),
  192. X+ #ifdef IPROCS
  193. X+     *pstate(),
  194. X+ #endif
  195. X      *StrIndex();
  196. X  
  197. X  extern Bufpos
  198. Xdiff -c ojove/keymaps.txt jove/keymaps.txt
  199. X*** ojove/keymaps.txt    Thu Jul 16 09:14:39 1987
  200. X--- jove/keymaps.txt    Thu Jun 11 15:43:50 1987
  201. X***************
  202. X*** 34,40 ****
  203. X      "search-reverse",        /* ^R */
  204. X      "search-forward",        /* ^S */
  205. X      "transpose-characters",        /* ^T */
  206. X!     "quadruple-numeric-argument",    /* ^U */
  207. X      "next-page",            /* ^V */
  208. X      "kill-region",            /* ^W */
  209. X      "prefix-2",            /* ^X */
  210. X--- 34,40 ----
  211. X      "search-reverse",        /* ^R */
  212. X      "search-forward",        /* ^S */
  213. X      "transpose-characters",        /* ^T */
  214. X!     "gather-numeric-argument",    /* ^U */
  215. X      "next-page",            /* ^V */
  216. X      "kill-region",            /* ^W */
  217. X      "prefix-2",            /* ^X */
  218. Xdiff -c ojove/macros.c jove/macros.c
  219. X*** ojove/macros.c    Thu Jul 16 09:14:41 1987
  220. X--- jove/macros.c    Fri Jun 19 16:01:00 1987
  221. X***************
  222. X*** 8,14 ****
  223. X  #include "jove.h"
  224. X  
  225. X  struct macro    *macros = 0;        /* Macros */
  226. X- data_obj    *LastCmd;
  227. X  
  228. X  private
  229. X  add_mac(new)
  230. X--- 8,13 ----
  231. X***************
  232. X*** 84,90 ****
  233. X          complain("[Too many macros at once!]");
  234. X      macstack[stackp] = mac;
  235. X      mac->m_offset = 0;
  236. X!     mac->m_ntimes = exp;
  237. X      mac->m_flags |= EXECUTE;
  238. X  }
  239. X  
  240. X--- 83,89 ----
  241. X          complain("[Too many macros at once!]");
  242. X      macstack[stackp] = mac;
  243. X      mac->m_offset = 0;
  244. X!     mac->m_ntimes = arg_value();
  245. X      mac->m_flags |= EXECUTE;
  246. X  }
  247. X  
  248. X***************
  249. X*** 362,368 ****
  250. X          if (!InJoverc) {
  251. X              TOstart("Warning", TRUE);
  252. X              Typeout("Warning: your macros file is in the old format.");
  253. X!             Typeout("Do you want me to convert \"%s\" to the new", pr_name(file));
  254. X              Typeout("format?");
  255. X              f_mess(msg);
  256. X              TOstop();
  257. X--- 361,367 ----
  258. X          if (!InJoverc) {
  259. X              TOstart("Warning", TRUE);
  260. X              Typeout("Warning: your macros file is in the old format.");
  261. X!             Typeout("Do you want me to convert \"%s\" to the new", pr_name(file, YES));
  262. X              Typeout("format?");
  263. X              f_mess(msg);
  264. X              TOstop();
  265. Xdiff -c ojove/marks.c jove/marks.c
  266. X*** ojove/marks.c    Thu Jul 16 09:14:42 1987
  267. X--- jove/marks.c    Wed Jun 24 13:22:48 1987
  268. X***************
  269. X*** 17,23 ****
  270. X  
  271. X      MarkSet(newmark, line, column);
  272. X      newmark->m_next = curbuf->b_marks;
  273. X!     newmark->m_floater = type;
  274. X      curbuf->b_marks = newmark;
  275. X      return newmark;
  276. X  }
  277. X--- 17,23 ----
  278. X  
  279. X      MarkSet(newmark, line, column);
  280. X      newmark->m_next = curbuf->b_marks;
  281. X!     newmark->m_flags = type;
  282. X      curbuf->b_marks = newmark;
  283. X      return newmark;
  284. X  }
  285. X***************
  286. X*** 70,76 ****
  287. X                  pmark = NMARKS - 1;
  288. X          } while (curbuf->b_markring[pmark] != 0);
  289. X  
  290. X!         curbuf->b_markring[pmark] = MakeMark(curline, curchar, MarksShouldFloat);
  291. X          ToMark(curmark);
  292. X          DelMark(curmark);
  293. X          curmark = 0;
  294. X--- 70,76 ----
  295. X                  pmark = NMARKS - 1;
  296. X          } while (curbuf->b_markring[pmark] != 0);
  297. X  
  298. X!         curbuf->b_markring[pmark] = MakeMark(curline, curchar, MarksShouldFloat ? M_FLOATER : M_FIXED);
  299. X          ToMark(curmark);
  300. X          DelMark(curmark);
  301. X          curmark = 0;
  302. X***************
  303. X*** 85,102 ****
  304. X  
  305. X  SetMark()
  306. X  {
  307. X!     if (exp_p)
  308. X          PopMark();
  309. X      else
  310. X!         DoSetMark(curline, curchar);
  311. X  }
  312. X  
  313. X! DoSetMark(l, c)
  314. X  Line    *l;
  315. X  {
  316. X      curbuf->b_themark = (curbuf->b_themark + 1) % NMARKS;
  317. X      if (curmark == 0)
  318. X!         curmark = MakeMark(l, c, MarksShouldFloat);
  319. X      else
  320. X          MarkSet(curmark, l, c);
  321. X      s_mess("[Point pushed]");
  322. X--- 85,107 ----
  323. X  
  324. X  SetMark()
  325. X  {
  326. X!     if (is_an_arg())
  327. X          PopMark();
  328. X      else
  329. X!         set_mark();
  330. X  }
  331. X  
  332. X! set_mark()
  333. X! {
  334. X!     do_set_mark(curline, curchar);
  335. X! }
  336. X! 
  337. X! do_set_mark(l, c)
  338. X  Line    *l;
  339. X  {
  340. X      curbuf->b_themark = (curbuf->b_themark + 1) % NMARKS;
  341. X      if (curmark == 0)
  342. X!         curmark = MakeMark(l, c, MarksShouldFloat ? M_FLOATER : M_FIXED);
  343. X      else
  344. X          MarkSet(curmark, l, c);
  345. X      s_mess("[Point pushed]");
  346. X***************
  347. X*** 151,167 ****
  348. X      if (curbuf->b_marks == 0)
  349. X          return;
  350. X      while (lp != line2->l_next) {
  351. X!         for (m = curbuf->b_marks; m != 0; m = m->m_next) {
  352. X! /*            if (!m->m_floater)
  353. X!                 continue; */
  354. X              if (m->m_line == lp)
  355. X                  m->m_char |= (1 << 15);
  356. X-         }
  357. X          lp = lp->l_next;
  358. X      }
  359. X      for (m = curbuf->b_marks; m; m = m->m_next) {
  360. X- /*        if (!m->m_floater)
  361. X-             continue; */
  362. X          if ((m->m_char & (1 << 15)) == 0)
  363. X              continue;    /* Not effected */
  364. X          m->m_char &= ~(1 << 15);
  365. X--- 156,167 ----
  366. X      if (curbuf->b_marks == 0)
  367. X          return;
  368. X      while (lp != line2->l_next) {
  369. X!         for (m = curbuf->b_marks; m != 0; m = m->m_next)
  370. X              if (m->m_line == lp)
  371. X                  m->m_char |= (1 << 15);
  372. X          lp = lp->l_next;
  373. X      }
  374. X      for (m = curbuf->b_marks; m; m = m->m_next) {
  375. X          if ((m->m_char & (1 << 15)) == 0)
  376. X              continue;    /* Not effected */
  377. X          m->m_char &= ~(1 << 15);
  378. X***************
  379. X*** 178,187 ****
  380. X--- 178,189 ----
  381. X                  m->m_char = char1 + (m->m_char - char2);
  382. X              else
  383. X                  m->m_char = char1;
  384. X+             m->m_flags |= M_BIG_DELETE;
  385. X              m->m_line = line1;
  386. X          } else {
  387. X              m->m_char = char1;
  388. X              m->m_line = line1;
  389. X+             m->m_flags |= M_BIG_DELETE;
  390. X          }
  391. X      }
  392. X  }
  393. X***************
  394. X*** 196,202 ****
  395. X      register Mark    *m;
  396. X  
  397. X      for (m = curbuf->b_marks; m != 0; m = m->m_next) {
  398. X!         if (!m->m_floater)
  399. X              continue;
  400. X          if (m->m_line == line1) {
  401. X              if (m->m_char > char1) {
  402. X--- 198,204 ----
  403. X      register Mark    *m;
  404. X  
  405. X      for (m = curbuf->b_marks; m != 0; m = m->m_next) {
  406. X!         if ((m->m_flags & M_FLOATER) == 0)
  407. X              continue;
  408. X          if (m->m_line == line1) {
  409. X              if (m->m_char > char1) {
  410. Xdiff -c ojove/misc.c jove/misc.c
  411. X*** ojove/misc.c    Thu Jul 16 09:14:43 1987
  412. X--- jove/misc.c    Fri Jul 10 09:25:50 1987
  413. X***************
  414. X*** 12,161 ****
  415. X  #include "termcap.h"
  416. X  #endif
  417. X  
  418. X- Digit()
  419. X- {
  420. X-     GetExp(LastKeyStruck);
  421. X- }
  422. X- 
  423. X- Digit0()
  424. X- {
  425. X-     GetExp('0');
  426. X- }
  427. X- 
  428. X- Digit1()
  429. X- {
  430. X-     GetExp('1');
  431. X- }
  432. X- 
  433. X- Digit2()
  434. X- {
  435. X-     GetExp('2');
  436. X- }
  437. X- 
  438. X- Digit3()
  439. X- {
  440. X-     GetExp('3');
  441. X- }
  442. X- 
  443. X- Digit4()
  444. X- {
  445. X-     GetExp('4');
  446. X- }
  447. X- 
  448. X- Digit5()
  449. X- {
  450. X-     GetExp('5');
  451. X- }
  452. X- 
  453. X- Digit6()
  454. X- {
  455. X-     GetExp('6');
  456. X- }
  457. X- 
  458. X- Digit7()
  459. X- {
  460. X-     GetExp('7');
  461. X- }
  462. X- 
  463. X- Digit8()
  464. X- {
  465. X-     GetExp('8');
  466. X- }
  467. X- 
  468. X- Digit9()
  469. X- {
  470. X-     GetExp('9');
  471. X- }
  472. X- 
  473. X  prCTIME()
  474. X  {
  475. X      s_mess(": %f %s", get_time((time_t *) 0, (char *) 0, 0, -1));
  476. X  }
  477. X  
  478. X- extern int    alarmed;
  479. X- 
  480. X- FourTime()
  481. X- {
  482. X-     int    oldc = LastKeyStruck,
  483. X-         newc;
  484. X-     int    nexp;
  485. X- 
  486. X-     alarmed = 0;
  487. X-     exp_p = YES;
  488. X-     this_cmd = ARG_CMD;
  489. X-     do {
  490. X-         if ((nexp = exp * 4) != 0)
  491. X-             exp = nexp;
  492. X-         if (!alarmed)
  493. X-             newc = waitchar();
  494. X-         else
  495. X-             newc = getch();
  496. X-         if (alarmed)
  497. X-             message(key_strokes);
  498. X-     } while (newc == oldc);
  499. X-     Ungetc(newc);
  500. X- }
  501. X- 
  502. X- int    exp_p,
  503. X-     exp;
  504. X- 
  505. X- GetExp(c)
  506. X- {
  507. X-     int    sign = 0;
  508. X-     static int    digited;
  509. X- 
  510. X-     if (!isdigit(c) && c != '-')
  511. X-         complain((char *) 0);
  512. X-     if (exp_p == NO) {    /* if we just got here */
  513. X-         exp = 0;    /* start over */
  514. X-         digited = NO;
  515. X-     } else if (exp_p == YES_NODIGIT) {
  516. X-         sign = (exp < 0) ? -1 : 1;
  517. X-         exp = 0;
  518. X-     }
  519. X- 
  520. X-     if (!sign)
  521. X-         sign = (exp < 0) ? -1 : 1;
  522. X-     if (sign == -1)
  523. X-         exp = -exp;
  524. X-     if (c == '-') {
  525. X-         sign = -sign;
  526. X-         goto goread;
  527. X-     }
  528. X-     for (;;) {
  529. X-         if (alarmed)
  530. X-             message(key_strokes);
  531. X-         if (isdigit(c)) {
  532. X-             exp = (exp * 10) + (c - '0');
  533. X-             digited++;
  534. X-         } else {
  535. X-             if (digited)
  536. X-                 exp_p = YES;
  537. X-             else {
  538. X-                 exp = 1;
  539. X-                 if (exp_p == NO)
  540. X-                     exp_p = YES_NODIGIT;
  541. X-             }
  542. X-             exp *= sign;
  543. X-             this_cmd = ARG_CMD;
  544. X-             Ungetc(c);
  545. X-             return;
  546. X-         }
  547. X- goread:        if (!alarmed)
  548. X-             c = waitchar();
  549. X-         else {
  550. X-             add_mess(NullStr);
  551. X-             c = getch();
  552. X-         }
  553. X-     }
  554. X- }
  555. X- 
  556. X  ChrToOct()
  557. X  {
  558. X!     int    c;
  559. X  
  560. X!     c = waitchar();
  561. X!     if (alarmed)
  562. X          message(key_strokes);
  563. X      ins_str(sprint("\\%03o", c), NO);
  564. X  }
  565. X--- 12,29 ----
  566. X  #include "termcap.h"
  567. X  #endif
  568. X  
  569. X  prCTIME()
  570. X  {
  571. X      s_mess(": %f %s", get_time((time_t *) 0, (char *) 0, 0, -1));
  572. X  }
  573. X  
  574. X  ChrToOct()
  575. X  {
  576. X!     int    c,
  577. X!         slow;
  578. X  
  579. X!     c = waitchar(&slow);
  580. X!     if (slow)
  581. X          message(key_strokes);
  582. X      ins_str(sprint("\\%03o", c), NO);
  583. X  }
  584. X***************
  585. X*** 197,209 ****
  586. X  
  587. X      if (curchar == 0 || (eolp() && curchar == 1))
  588. X          complain((char *) 0);    /* BEEP */
  589. X-     exp = 1;
  590. X      if (eolp())
  591. X!         BackChar();
  592. X      before = linebuf[curchar - 1];
  593. X!     DelPChar();
  594. X!     ForChar();
  595. X!     Insert(before);
  596. X  }
  597. X  
  598. X  /* Switch current line with previous one */
  599. X--- 65,76 ----
  600. X  
  601. X      if (curchar == 0 || (eolp() && curchar == 1))
  602. X          complain((char *) 0);    /* BEEP */
  603. X      if (eolp())
  604. X!         b_char(1);
  605. X      before = linebuf[curchar - 1];
  606. X!     del_char(BACKWARD, 1);
  607. X!     f_char(1);
  608. X!     insert_c(before, 1);
  609. X  }
  610. X  
  611. X  /* Switch current line with previous one */
  612. X***************
  613. X*** 214,220 ****
  614. X  
  615. X      if (firstp(curline))
  616. X          return;
  617. X-     exp = 1;
  618. X      lsave();
  619. X      old_prev = curline->l_prev->l_dline;
  620. X      curline->l_prev->l_dline = curline->l_dline;
  621. X--- 81,86 ----
  622. X***************
  623. X*** 221,227 ****
  624. X      curline->l_dline = old_prev;
  625. X      getDOT();
  626. X      if (!lastp(curline))
  627. X!         line_move(FORWARD, NO);
  628. X      modify();
  629. X  }
  630. X  
  631. X--- 87,93 ----
  632. X      curline->l_dline = old_prev;
  633. X      getDOT();
  634. X      if (!lastp(curline))
  635. X!         line_move(FORWARD, 1, NO);
  636. X      modify();
  637. X  }
  638. X  
  639. X***************
  640. X*** 239,252 ****
  641. X  {
  642. X      Line    *line2;
  643. X      int    char2;
  644. X  
  645. X!     if (exp_p) {
  646. X!         if (exp == 0) {    /* Kill to beginning of line */
  647. X              line2 = curline;
  648. X              char2 = 0;
  649. X          } else {
  650. X!             line2 = next_line(curline, exp);
  651. X!             if ((LineDist(curline, line2) < exp) || (line2 == curline))
  652. X                  char2 = length(line2);
  653. X              else
  654. X                  char2 = 0;
  655. X--- 105,119 ----
  656. X  {
  657. X      Line    *line2;
  658. X      int    char2;
  659. X+     int    num = arg_value();
  660. X  
  661. X!     if (is_an_arg()) {
  662. X!         if (num == 0) {    /* Kill to beginning of line */
  663. X              line2 = curline;
  664. X              char2 = 0;
  665. X          } else {
  666. X!             line2 = next_line(curline, num);
  667. X!             if ((LineDist(curline, line2) < num) || (line2 == curline))
  668. X                  char2 = length(line2);
  669. X              else
  670. X                  char2 = 0;
  671. X***************
  672. X*** 264,274 ****
  673. X      reg_kill(line2, char2, 0);
  674. X  }
  675. X  
  676. X! /* Kill to beginning of sentence */
  677. X  
  678. X  KillBos()
  679. X  {
  680. X!     exp = -exp;
  681. X      KillEos();
  682. X  }
  683. X  
  684. X--- 131,141 ----
  685. X      reg_kill(line2, char2, 0);
  686. X  }
  687. X  
  688. X! /* kill to beginning of sentence */
  689. X  
  690. X  KillBos()
  691. X  {
  692. X!     negate_arg_value();
  693. X      KillEos();
  694. X  }
  695. X  
  696. X***************
  697. X*** 316,330 ****
  698. X  {
  699. X      register data_obj    *cp;
  700. X      register int    c;
  701. X  
  702. X!     c = waitchar();
  703. X!     if (c == CTL(G)) {
  704. X          message("[Aborted]");
  705. X          rbell();
  706. X          return;
  707. X      }
  708. X  
  709. X!     if (alarmed)
  710. X          message(key_strokes);
  711. X  
  712. X      cp = map[c];
  713. X--- 183,198 ----
  714. X  {
  715. X      register data_obj    *cp;
  716. X      register int    c;
  717. X+     int    slow;
  718. X  
  719. X!     c = waitchar(&slow);
  720. X!     if (c == CTL('G')) {
  721. X          message("[Aborted]");
  722. X          rbell();
  723. X          return;
  724. X      }
  725. X  
  726. X!     if (slow)
  727. X          message(key_strokes);
  728. X  
  729. X      cp = map[c];
  730. X***************
  731. X*** 348,354 ****
  732. X      line = killbuf[killptr];
  733. X      lp = lastline(line);
  734. X      dot = DoYank(line, 0, lp, length(lp), curline, curchar, curbuf);
  735. X!     SetMark();
  736. X      SetDot(dot);
  737. X  }
  738. X  
  739. X--- 216,222 ----
  740. X      line = killbuf[killptr];
  741. X      lp = lastline(line);
  742. X      dot = DoYank(line, 0, lp, length(lp), curline, curchar, curbuf);
  743. X!     set_mark();
  744. X      SetDot(dot);
  745. X  }
  746. X  
  747. X***************
  748. X*** 357,363 ****
  749. X      if (!ModBufs(NO))
  750. X          message("[No buffers need saving]");
  751. X      else
  752. X!         put_bufs(exp_p);
  753. X  }
  754. X  
  755. X  put_bufs(askp)
  756. X--- 225,231 ----
  757. X      if (!ModBufs(NO))
  758. X          message("[No buffers need saving]");
  759. X      else
  760. X!         put_bufs(is_an_arg());
  761. X  }
  762. X  
  763. X  put_bufs(askp)
  764. X***************
  765. X*** 403,418 ****
  766. X      Line    *newline;
  767. X  
  768. X  #ifndef ANSICODES
  769. X!     if (exp_p == NO)
  770. X          return;
  771. X  #else
  772. X!     if (exp_p == NO || exp <= 0) {
  773. X          if (SP)
  774. X              putpad(SP, 1);    /* Ask for cursor position */
  775. X          return;
  776. X      }
  777. X  #endif
  778. X!     newline = next_line(curbuf->b_first, exp - 1);
  779. X      PushPntp(newline);
  780. X      SetLine(newline);
  781. X  }
  782. X--- 271,286 ----
  783. X      Line    *newline;
  784. X  
  785. X  #ifndef ANSICODES
  786. X!     if (!is_an_arg())
  787. X          return;
  788. X  #else
  789. X!     if (!is_an_arg() || arg_value() <= 0) {
  790. X          if (SP)
  791. X              putpad(SP, 1);    /* Ask for cursor position */
  792. X          return;
  793. X      }
  794. X  #endif
  795. X!     newline = next_line(curbuf->b_first, arg_value() - 1);
  796. X      PushPntp(newline);
  797. X      SetLine(newline);
  798. X  }
  799. X***************
  800. X*** 440,452 ****
  801. X      static char *unsupported = "[Unsupported ANSI code received]";
  802. X  
  803. X      while (isdigit(c = getch()))
  804. X!         num1 = (num1*10) + (c - '0');
  805. X  
  806. X      switch (c) {
  807. X      case ';':
  808. X          num2 = 0;
  809. X          while (isdigit(c = getch()))
  810. X!             num2 = (num2*10) + (c - '0');
  811. X          switch (c) {
  812. X          case 'R':
  813. X              MoveToCursor(--num1, --num2);
  814. X--- 308,320 ----
  815. X      static char *unsupported = "[Unsupported ANSI code received]";
  816. X  
  817. X      while (isdigit(c = getch()))
  818. X!         num1 = (num1 * 10) + (c - '0');
  819. X  
  820. X      switch (c) {
  821. X      case ';':
  822. X          num2 = 0;
  823. X          while (isdigit(c = getch()))
  824. X!             num2 = (num2 * 10) + (c - '0');
  825. X          switch (c) {
  826. X          case 'R':
  827. X              MoveToCursor(--num1, --num2);
  828. X***************
  829. X*** 459,468 ****
  830. X          }
  831. X          break;
  832. X      case 'A':
  833. X!         line_move(BACKWARD, YES);
  834. X          break;
  835. X      case 'B':
  836. X!         line_move(FORWARD, YES);
  837. X          break;
  838. X      case 'C':
  839. X          ForChar();
  840. X--- 327,336 ----
  841. X          }
  842. X          break;
  843. X      case 'A':
  844. X!         PrevLine();
  845. X          break;
  846. X      case 'B':
  847. X!         NextLine();
  848. X          break;
  849. X      case 'C':
  850. X          ForChar();
  851. X***************
  852. X*** 479,484 ****
  853. X--- 347,369 ----
  854. X              break;
  855. X          }
  856. X          /* FALL THROUGH */
  857. X+ 
  858. X+     case 'P':
  859. X+         PrevPage();
  860. X+         break;
  861. X+ 
  862. X+     case 'Q':
  863. X+         NextPage();
  864. X+         break;
  865. X+ 
  866. X+     case 'R':
  867. X+         UpScroll();
  868. X+         break;
  869. X+ 
  870. X+     case 'S':
  871. X+         DownScroll();
  872. X+         break;
  873. X+ 
  874. X      default:
  875. X          complain(unsupported);
  876. X      }
  877. Xdiff -c ojove/move.c jove/move.c
  878. X*** ojove/move.c    Thu Jul 16 09:14:44 1987
  879. X--- jove/move.c    Fri Jun 12 11:53:33 1987
  880. X***************
  881. X*** 10,26 ****
  882. X  
  883. X  static int    line_pos;
  884. X  
  885. X! ForChar()
  886. X  {
  887. X-     register int    num = exp;
  888. X  
  889. X!     if (exp < 0) {
  890. X!         exp = -exp;
  891. X!         BackChar();
  892. X          return;
  893. X      }
  894. X!     exp = 1;
  895. X!     while (--num >= 0) {
  896. X          if (eolp()) {            /* Go to the next Line */
  897. X              if (curline->l_next == 0)
  898. X                  break;
  899. X--- 10,24 ----
  900. X  
  901. X  static int    line_pos;
  902. X  
  903. X! f_char(n)
  904. X! register int    n;
  905. X  {
  906. X  
  907. X!     if (n < 0) {
  908. X!         b_char(-n);
  909. X          return;
  910. X      }
  911. X!     while (--n >= 0) {
  912. X          if (eolp()) {            /* Go to the next Line */
  913. X              if (curline->l_next == 0)
  914. X                  break;
  915. X***************
  916. X*** 30,46 ****
  917. X      }
  918. X  }
  919. X  
  920. X! BackChar()
  921. X  {
  922. X-     register int    num = exp;
  923. X  
  924. X!     if (exp < 0) {
  925. X!         exp = -exp;
  926. X!         ForChar();
  927. X          return;
  928. X      }
  929. X!     exp = 1;
  930. X!     while (--num >= 0) {
  931. X          if (bolp()) {
  932. X              if (curline->l_prev == 0)
  933. X                  break;
  934. X--- 28,42 ----
  935. X      }
  936. X  }
  937. X  
  938. X! b_char(n)
  939. X! register int    n;
  940. X  {
  941. X  
  942. X!     if (n < 0) {
  943. X!         f_char(-n);
  944. X          return;
  945. X      }
  946. X!     while (--n >= 0) {
  947. X          if (bolp()) {
  948. X              if (curline->l_prev == 0)
  949. X                  break;
  950. X***************
  951. X*** 51,61 ****
  952. X      }
  953. X  }
  954. X  
  955. X  NextLine()
  956. X  {
  957. X      if ((curline == curbuf->b_last) && eolp())
  958. X          complain(NullStr);
  959. X!     line_move(FORWARD, YES);
  960. X  }
  961. X  
  962. X  PrevLine()
  963. X--- 47,67 ----
  964. X      }
  965. X  }
  966. X  
  967. X+ ForChar()
  968. X+ {
  969. X+     f_char(arg_value());
  970. X+ }
  971. X+ 
  972. X+ BackChar()
  973. X+ {
  974. X+     b_char(arg_value());
  975. X+ }
  976. X+ 
  977. X  NextLine()
  978. X  {
  979. X      if ((curline == curbuf->b_last) && eolp())
  980. X          complain(NullStr);
  981. X!     line_move(FORWARD, arg_value(), YES);
  982. X  }
  983. X  
  984. X  PrevLine()
  985. X***************
  986. X*** 62,68 ****
  987. X  {
  988. X      if ((curline == curbuf->b_first) && bolp())
  989. X          complain(NullStr);
  990. X!     line_move(BACKWARD, YES);
  991. X  }
  992. X  
  993. X  /* moves to a different line in DIR; LINE_CMD says whether this is
  994. X--- 68,74 ----
  995. X  {
  996. X      if ((curline == curbuf->b_first) && bolp())
  997. X          complain(NullStr);
  998. X!     line_move(BACKWARD, arg_value(), YES);
  999. X  }
  1000. X  
  1001. X  /* moves to a different line in DIR; LINE_CMD says whether this is
  1002. X***************
  1003. X*** 69,80 ****
  1004. X     being called from NextLine() or PrevLine(), in which case it tries
  1005. X     to line up the column with the column of the current line */
  1006. X  
  1007. X! line_move(dir, line_cmd)
  1008. X  {
  1009. X      Line    *(*proc)() = (dir == FORWARD) ? next_line : prev_line;
  1010. X      Line    *line;
  1011. X  
  1012. X!     line = (*proc)(curline, exp);
  1013. X      if (line == curline) {
  1014. X          (dir == FORWARD) ? Eol() : Bol();
  1015. X          return;
  1016. X--- 75,86 ----
  1017. X     being called from NextLine() or PrevLine(), in which case it tries
  1018. X     to line up the column with the column of the current line */
  1019. X  
  1020. X! line_move(dir, n, line_cmd)
  1021. X  {
  1022. X      Line    *(*proc)() = (dir == FORWARD) ? next_line : prev_line;
  1023. X      Line    *line;
  1024. X  
  1025. X!     line = (*proc)(curline, n);
  1026. X      if (line == curline) {
  1027. X          (dir == FORWARD) ? Eol() : Bol();
  1028. X          return;
  1029. X***************
  1030. X*** 142,147 ****
  1031. X--- 148,154 ----
  1032. X     with all the kludgery involved with paragraphs, and moving backwards
  1033. X     is particularly yucky. */
  1034. X  
  1035. X+ private
  1036. X  to_sent(dir)
  1037. X  {
  1038. X      Bufpos    *new,
  1039. X***************
  1040. X*** 152,158 ****
  1041. X  
  1042. X      new = dosearch("^[ \t]*$\\|[?.!]", dir, 1);
  1043. X      if (new == 0) {
  1044. X!         (dir < 0) ? ToFirst() : ToLast();
  1045. X          return;
  1046. X      }
  1047. X      SetDot(new);
  1048. X--- 159,165 ----
  1049. X  
  1050. X      new = dosearch("^[ \t]*$\\|[?.!]", dir, 1);
  1051. X      if (new == 0) {
  1052. X!         (dir == BACKWARD) ? ToFirst() : ToLast();
  1053. X          return;
  1054. X      }
  1055. X      SetDot(new);
  1056. X***************
  1057. X*** 168,174 ****
  1058. X      }
  1059. X      if (blnkp(linebuf)) {
  1060. X          Bol();
  1061. X!         BackChar();
  1062. X          if (old.p_line == curline && old.p_char >= curchar) {
  1063. X              to_word(1);    /* Oh brother this is painful */
  1064. X              to_sent(1);
  1065. X--- 175,181 ----
  1066. X      }
  1067. X      if (blnkp(linebuf)) {
  1068. X          Bol();
  1069. X!         b_char(1);
  1070. X          if (old.p_line == curline && old.p_char >= curchar) {
  1071. X              to_word(1);    /* Oh brother this is painful */
  1072. X              to_sent(1);
  1073. X***************
  1074. X*** 186,201 ****
  1075. X  
  1076. X  Bos()
  1077. X  {
  1078. X!     int    num = exp;
  1079. X  
  1080. X!     if (exp < 0) {
  1081. X!         exp = -exp;
  1082. X          Eos();
  1083. X          return;
  1084. X      }
  1085. X  
  1086. X-     exp = 1;
  1087. X- 
  1088. X      while (--num >= 0) {
  1089. X          to_sent(-1);
  1090. X          if (bobp())
  1091. X--- 193,206 ----
  1092. X  
  1093. X  Bos()
  1094. X  {
  1095. X!     register int    num = arg_value();
  1096. X  
  1097. X!     if (num < 0) {
  1098. X!         negate_arg_value();
  1099. X          Eos();
  1100. X          return;
  1101. X      }
  1102. X  
  1103. X      while (--num >= 0) {
  1104. X          to_sent(-1);
  1105. X          if (bobp())
  1106. X***************
  1107. X*** 205,220 ****
  1108. X  
  1109. X  Eos()
  1110. X  {
  1111. X!     int    num = exp;
  1112. X  
  1113. X!     if (exp < 0) {
  1114. X!         exp = -exp;
  1115. X          Bos();
  1116. X          return;
  1117. X      }
  1118. X  
  1119. X-     exp = 1;
  1120. X- 
  1121. X      while (--num >= 0) {
  1122. X          to_sent(1);
  1123. X          if (eobp())
  1124. X--- 210,223 ----
  1125. X  
  1126. X  Eos()
  1127. X  {
  1128. X!     register int    num = arg_value();
  1129. X  
  1130. X!     if (num < 0) {
  1131. X!         negate_arg_value();
  1132. X          Bos();
  1133. X          return;
  1134. X      }
  1135. X  
  1136. X      while (--num >= 0) {
  1137. X          to_sent(1);
  1138. X          if (eobp())
  1139. X***************
  1140. X*** 222,240 ****
  1141. X      }
  1142. X  }
  1143. X  
  1144. X! ForWord()
  1145. X  {
  1146. X      register char    c;
  1147. X-     register int    num = exp;
  1148. X  
  1149. X!     if (exp < 0) {
  1150. X!         exp = -exp;
  1151. X!         BackWord();
  1152. X          return;
  1153. X      }
  1154. X-     exp = 1;
  1155. X      while (--num >= 0) {
  1156. X!         to_word(1);
  1157. X          while ((c = linebuf[curchar]) != 0 && isword(c))
  1158. X              curchar++;
  1159. X          if (eobp())
  1160. X--- 225,241 ----
  1161. X      }
  1162. X  }
  1163. X  
  1164. X! f_word(num)
  1165. X! register int    num;
  1166. X  {
  1167. X      register char    c;
  1168. X  
  1169. X!     if (num < 0) {
  1170. X!         b_word(-num);
  1171. X          return;
  1172. X      }
  1173. X      while (--num >= 0) {
  1174. X!         to_word(FORWARD);
  1175. X          while ((c = linebuf[curchar]) != 0 && isword(c))
  1176. X              curchar++;
  1177. X          if (eobp())
  1178. X***************
  1179. X*** 243,261 ****
  1180. X      this_cmd = 0;    /* Semi kludge to stop some unfavorable behavior */
  1181. X  }
  1182. X  
  1183. X! BackWord()
  1184. X  {
  1185. X-     register int    num = exp;
  1186. X      register char    c;
  1187. X  
  1188. X!     if (exp < 0) {
  1189. X!         exp = -exp;
  1190. X!         ForWord();
  1191. X          return;
  1192. X      }
  1193. X-     exp = 1;
  1194. X      while (--num >= 0) {
  1195. X!         to_word(-1);
  1196. X          while (!bolp() && (c = linebuf[curchar - 1], isword(c)))
  1197. X              --curchar;
  1198. X          if (bobp())
  1199. X--- 244,260 ----
  1200. X      this_cmd = 0;    /* Semi kludge to stop some unfavorable behavior */
  1201. X  }
  1202. X  
  1203. X! b_word(num)
  1204. X! register int    num;
  1205. X  {
  1206. X      register char    c;
  1207. X  
  1208. X!     if (num < 0) {
  1209. X!         f_word(-num);
  1210. X          return;
  1211. X      }
  1212. X      while (--num >= 0) {
  1213. X!         to_word(BACKWARD);
  1214. X          while (!bolp() && (c = linebuf[curchar - 1], isword(c)))
  1215. X              --curchar;
  1216. X          if (bobp())
  1217. X***************
  1218. X*** 263,265 ****
  1219. X--- 262,275 ----
  1220. X      }
  1221. X      this_cmd = 0;
  1222. X  }
  1223. X+ 
  1224. X+ ForWord()
  1225. X+ {
  1226. X+     f_word(arg_value());
  1227. X+ }
  1228. X+ 
  1229. X+ BackWord()
  1230. X+ {
  1231. X+     b_word(arg_value());
  1232. X+ }
  1233. X+ 
  1234. Xdiff -c ojove/paragraph.c jove/paragraph.c
  1235. X*** ojove/paragraph.c    Thu Jul 16 09:14:45 1987
  1236. X--- jove/paragraph.c    Wed Jun 24 12:43:24 1987
  1237. X***************
  1238. X*** 204,210 ****
  1239. X      int    this_indent;
  1240. X      Bufpos    orig;        /* remember where we were when we started */
  1241. X  
  1242. X-     exp = 1;
  1243. X      DOTsave(&orig);
  1244. X  strt:
  1245. X      this = curline;
  1246. X--- 204,209 ----
  1247. X***************
  1248. X*** 218,224 ****
  1249. X                  if (firstp(curline))
  1250. X                      complain((char *) 0);
  1251. X                  else
  1252. X!                     line_move(BACKWARD, NO);
  1253. X              goto strt;
  1254. X          } else {
  1255. X              while (i_blank(curline))
  1256. X--- 217,223 ----
  1257. X                  if (firstp(curline))
  1258. X                      complain((char *) 0);
  1259. X                  else
  1260. X!                     line_move(BACKWARD, 1, NO);
  1261. X              goto strt;
  1262. X          } else {
  1263. X              while (i_blank(curline))
  1264. X***************
  1265. X*** 225,231 ****
  1266. X                  if (lastp(curline))
  1267. X                      complain((char *) 0);
  1268. X                  else
  1269. X!                     line_move(FORWARD, NO);
  1270. X              head = curline;
  1271. X              next = curline->l_next;
  1272. X              if (!i_bsblank(next))
  1273. X--- 224,230 ----
  1274. X                  if (lastp(curline))
  1275. X                      complain((char *) 0);
  1276. X                  else
  1277. X!                     line_move(FORWARD, 1, NO);
  1278. X              head = curline;
  1279. X              next = curline->l_next;
  1280. X              if (!i_bsblank(next))
  1281. X***************
  1282. X*** 302,308 ****
  1283. X  
  1284. X  Justify()
  1285. X  {
  1286. X!     use_lmargin = (exp_p != NO);
  1287. X      find_para(BACKWARD);
  1288. X      DoJustify(para_head, 0, para_tail, length(para_tail), NO,
  1289. X            use_lmargin ? LMargin : body_indent);
  1290. X--- 301,307 ----
  1291. X  
  1292. X  Justify()
  1293. X  {
  1294. X!     use_lmargin = is_an_arg();
  1295. X      find_para(BACKWARD);
  1296. X      DoJustify(para_head, 0, para_tail, length(para_tail), NO,
  1297. X            use_lmargin ? LMargin : body_indent);
  1298. X***************
  1299. X*** 339,345 ****
  1300. X      Line    *rl1,
  1301. X          *rl2;
  1302. X  
  1303. X!     use_lmargin = (exp_p != NO);
  1304. X      (void) fixorder(&l1, &c1, &l2, &c2);
  1305. X      do {
  1306. X          DotTo(l1, c1);
  1307. X--- 338,344 ----
  1308. X      Line    *rl1,
  1309. X          *rl2;
  1310. X  
  1311. X!     use_lmargin = is_an_arg();
  1312. X      (void) fixorder(&l1, &c1, &l2, &c2);
  1313. X      do {
  1314. X          DotTo(l1, c1);
  1315. X***************
  1316. X*** 346,352 ****
  1317. X          find_para(FORWARD);
  1318. X          rl1 = max_line(l1, para_head);
  1319. X          rl2 = min_line(l2, para_tail);
  1320. X!         tailmark = MakeMark(para_tail, 0, FLOATER);
  1321. X          DoJustify(rl1, (rl1 == l1) ? c1 : 0, rl2,
  1322. X                (rl2 == l2) ? c2 : length(rl2),
  1323. X                NO, use_lmargin ? LMargin : body_indent);
  1324. X--- 345,351 ----
  1325. X          find_para(FORWARD);
  1326. X          rl1 = max_line(l1, para_head);
  1327. X          rl2 = min_line(l2, para_tail);
  1328. X!         tailmark = MakeMark(para_tail, 0, M_FLOATER);
  1329. X          DoJustify(rl1, (rl1 == l1) ? c1 : 0, rl2,
  1330. X                (rl2 == l2) ? c2 : length(rl2),
  1331. X                NO, use_lmargin ? LMargin : body_indent);
  1332. X***************
  1333. X*** 356,362 ****
  1334. X      } while (l1 != 0 && l2 != rl2);
  1335. X  }
  1336. X  
  1337. X! do_rfill()
  1338. X  {
  1339. X      Mark    *mp = CurMark();
  1340. X      Line    *l1 = curline,
  1341. X--- 355,361 ----
  1342. X      } while (l1 != 0 && l2 != rl2);
  1343. X  }
  1344. X  
  1345. X! do_rfill(ulm)
  1346. X  {
  1347. X      Mark    *mp = CurMark();
  1348. X      Line    *l1 = curline,
  1349. X***************
  1350. X*** 364,370 ****
  1351. X      int    c1 = curchar,
  1352. X          c2 = mp->m_char;
  1353. X  
  1354. X!     use_lmargin = (exp_p != NO);
  1355. X      (void) fixorder(&l1, &c1, &l2, &c2);
  1356. X      DoJustify(l1, c1, l2, c2, NO, use_lmargin ? LMargin : 0);
  1357. X  }
  1358. X--- 363,369 ----
  1359. X      int    c1 = curchar,
  1360. X          c2 = mp->m_char;
  1361. X  
  1362. X!     use_lmargin = ulm;
  1363. X      (void) fixorder(&l1, &c1, &l2, &c2);
  1364. X      DoJustify(l1, c1, l2, c2, NO, use_lmargin ? LMargin : 0);
  1365. X  }
  1366. X***************
  1367. X*** 403,411 ****
  1368. X          nspace = 0;
  1369. X  
  1370. X      if (diff > nspace)
  1371. X!         DoTimes(DelPChar(), (diff - nspace));
  1372. X      else if (diff < nspace)
  1373. X!         DoTimes(Insert(' '), (nspace - diff));
  1374. X  }
  1375. X  
  1376. X  DoJustify(l1, c1, l2, c2, scrunch, indent)
  1377. X--- 402,410 ----
  1378. X          nspace = 0;
  1379. X  
  1380. X      if (diff > nspace)
  1381. X!         del_char(BACKWARD, (diff - nspace));
  1382. X      else if (diff < nspace)
  1383. X!         insert_c(' ', (nspace - diff));
  1384. X  }
  1385. X  
  1386. X  DoJustify(l1, c1, l2, c2, scrunch, indent)
  1387. X***************
  1388. X*** 414,423 ****
  1389. X  {
  1390. X      int    okay_char = -1;
  1391. X      char    *cp;
  1392. X!     Mark    *savedot = MakeMark(curline, curchar, FLOATER),
  1393. X          *endmark;
  1394. X  
  1395. X-     exp = 1;
  1396. X      (void) fixorder(&l1, &c1, &l2, &c2);    /* l1/c1 will be before l2/c2 */
  1397. X      DotTo(l1, c1);
  1398. X      if (get_indent(l1) >= c1) {
  1399. X--- 413,421 ----
  1400. X  {
  1401. X      int    okay_char = -1;
  1402. X      char    *cp;
  1403. X!     Mark    *savedot = MakeMark(curline, curchar, M_FLOATER),
  1404. X          *endmark;
  1405. X  
  1406. X      (void) fixorder(&l1, &c1, &l2, &c2);    /* l1/c1 will be before l2/c2 */
  1407. X      DotTo(l1, c1);
  1408. X      if (get_indent(l1) >= c1) {
  1409. X***************
  1410. X*** 427,474 ****
  1411. X          }
  1412. X          ToIndent();
  1413. X      }
  1414. X!     endmark = MakeMark(l2, c2, FLOATER);
  1415. X  
  1416. X      for (;;) {
  1417. X!         cp = StrIndex(1, linebuf, curchar, ' ');
  1418. X!         if (cp == 0)
  1419. X!             Eol();
  1420. X!         else
  1421. X!             curchar = (cp - linebuf);
  1422. X!         if (curline == endmark->m_line && curchar >= endmark->m_char)
  1423. X!             goto outahere;
  1424. X!         if (eolp()) {
  1425. X!             ins_str("  ", NO);
  1426. X!             DelNChar();    /* delete line separator */
  1427. X!             curchar -= 2;    /* back over the spaces */
  1428. X!         }
  1429. X!         /* at this point we are ALWAYS sitting right after
  1430. X!            a word - that is, just before some spaces or the
  1431. X!            end of the line */
  1432. X!         if (calc_pos(linebuf, curchar) <= RMargin) {
  1433. X              okay_char = curchar;
  1434. X              do_space();
  1435. X-             continue;
  1436. X          }
  1437. X- 
  1438. X-         /* if we get here, we have done all we can for
  1439. X-            this line - now we split the line, or just move
  1440. X-            to the next one */
  1441. X          if (okay_char > 0)
  1442. X              curchar = okay_char;            
  1443. X          if (curline == endmark->m_line && curchar >= endmark->m_char)
  1444. X              goto outahere;
  1445. X!         /* can't fit in small margin, so we do the best we can */
  1446. X          if (eolp()) {
  1447. X!             line_move(FORWARD, NO);
  1448. X              n_indent(indent);
  1449. X          } else {
  1450. X-             /* insert a line break - line WAS too long */
  1451. X              DelWtSpace();
  1452. X              LineInsert(1);
  1453. X              if (scrunch && TwoBlank()) {
  1454. X                  Eol();
  1455. X!                 DelNChar();
  1456. X              }
  1457. X              n_indent(indent);
  1458. X          }
  1459. X--- 425,464 ----
  1460. X          }
  1461. X          ToIndent();
  1462. X      }
  1463. X!     endmark = MakeMark(l2, c2, M_FLOATER);
  1464. X  
  1465. X      for (;;) {
  1466. X!         while (calc_pos(linebuf, curchar) < RMargin) {
  1467. X!             if (curline == endmark->m_line && curchar >= endmark->m_char)
  1468. X!                 goto outahere;
  1469. X              okay_char = curchar;
  1470. X+             if (eolp()) {
  1471. X+                 del_char(FORWARD, 1);    /* Delete line separator. */
  1472. X+                 ins_str("  ", NO);
  1473. X+             } else {
  1474. X+                 cp = StrIndex(1, linebuf, curchar + 1, ' ');
  1475. X+                 if (cp == 0)
  1476. X+                     Eol();
  1477. X+                 else
  1478. X+                     curchar = (cp - linebuf);
  1479. X+             }
  1480. X              do_space();
  1481. X          }
  1482. X          if (okay_char > 0)
  1483. X              curchar = okay_char;            
  1484. X          if (curline == endmark->m_line && curchar >= endmark->m_char)
  1485. X              goto outahere;
  1486. X! 
  1487. X!         /* Can't fit in small margin, so we do the best we can. */
  1488. X          if (eolp()) {
  1489. X!             line_move(FORWARD, 1, NO);
  1490. X              n_indent(indent);
  1491. X          } else {
  1492. X              DelWtSpace();
  1493. X              LineInsert(1);
  1494. X              if (scrunch && TwoBlank()) {
  1495. X                  Eol();
  1496. X!                 del_char(FORWARD, 1);
  1497. X              }
  1498. X              n_indent(indent);
  1499. X          }
  1500. X***************
  1501. X*** 486,492 ****
  1502. X  
  1503. X  DoPara(dir)
  1504. X  {
  1505. X!     register int    num = exp,
  1506. X              first_time = TRUE;    
  1507. X  
  1508. X      while (--num >= 0) {
  1509. X--- 476,482 ----
  1510. X  
  1511. X  DoPara(dir)
  1512. X  {
  1513. X!     register int    num = arg_value(),
  1514. X              first_time = TRUE;    
  1515. X  
  1516. X      while (--num >= 0) {
  1517. X***************
  1518. X*** 495,501 ****
  1519. X              ((!first_time) || ((para_head == curline) && bolp()))) {
  1520. X                  if (bobp())
  1521. X                      complain((char *) 0);
  1522. X!             BackChar();
  1523. X              first_time = !first_time;
  1524. X              goto tryagain;
  1525. X          }
  1526. X--- 485,491 ----
  1527. X              ((!first_time) || ((para_head == curline) && bolp()))) {
  1528. X                  if (bobp())
  1529. X                      complain((char *) 0);
  1530. X!             b_char(1);
  1531. X              first_time = !first_time;
  1532. X              goto tryagain;
  1533. X          }
  1534. X***************
  1535. X*** 502,508 ****
  1536. X          SetLine((dir == BACKWARD) ? para_head : para_tail);
  1537. X          if (dir == BACKWARD && !firstp(curline) &&
  1538. X              i_blank(curline->l_prev))
  1539. X!             line_move(BACKWARD, NO);
  1540. X          else if (dir == FORWARD) {
  1541. X              if (lastp(curline)) {
  1542. X                  Eol();
  1543. X--- 492,498 ----
  1544. X          SetLine((dir == BACKWARD) ? para_head : para_tail);
  1545. X          if (dir == BACKWARD && !firstp(curline) &&
  1546. X              i_blank(curline->l_prev))
  1547. X!             line_move(BACKWARD, 1, NO);
  1548. X          else if (dir == FORWARD) {
  1549. X              if (lastp(curline)) {
  1550. X                  Eol();
  1551. X***************
  1552. X*** 509,515 ****
  1553. X                  break;
  1554. X              }
  1555. X              /* otherwise */
  1556. X!             line_move(FORWARD, NO);
  1557. X          }
  1558. X      }
  1559. X  }
  1560. X--- 499,505 ----
  1561. X                  break;
  1562. X              }
  1563. X              /* otherwise */
  1564. X!             line_move(FORWARD, 1, NO);
  1565. X          }
  1566. X      }
  1567. X  }
  1568. Xdiff -c ojove/proc.c jove/proc.c
  1569. X*** ojove/proc.c    Thu Jul 16 09:14:48 1987
  1570. X--- jove/proc.c    Thu Jun 25 09:45:20 1987
  1571. X***************
  1572. X*** 124,130 ****
  1573. X      }
  1574. X      if (cur_error != 0)
  1575. X          ShowErr();
  1576. X-     exp = 1;
  1577. X  }
  1578. X  
  1579. X  /* Free up all the errors */
  1580. X--- 124,129 ----
  1581. X***************
  1582. X*** 145,153 ****
  1583. X          noerrs[] = "No errors!";
  1584. X  
  1585. X  private
  1586. X! toerror(forward)
  1587. X  {
  1588. X-     register int    i;
  1589. X      register struct error    *e = cur_error;
  1590. X  
  1591. X      if (e == 0)
  1592. X--- 144,151 ----
  1593. X          noerrs[] = "No errors!";
  1594. X  
  1595. X  private
  1596. X! toerror(forward, num)
  1597. X  {
  1598. X      register struct error    *e = cur_error;
  1599. X  
  1600. X      if (e == 0)
  1601. X***************
  1602. X*** 156,162 ****
  1603. X          (!forward && (e->er_prev == 0)))
  1604. X          complain(errbounds, forward ? "last" : "first");
  1605. X  
  1606. X!     for (i = 0; i < exp; i++) {
  1607. X          if ((e = forward ? e->er_next : e->er_prev) == 0)
  1608. X              break;
  1609. X          cur_error = e;
  1610. X--- 154,160 ----
  1611. X          (!forward && (e->er_prev == 0)))
  1612. X          complain(errbounds, forward ? "last" : "first");
  1613. X  
  1614. X!     while (--num >= 0) {
  1615. X          if ((e = forward ? e->er_next : e->er_prev) == 0)
  1616. X              break;
  1617. X          cur_error = e;
  1618. X***************
  1619. X*** 187,194 ****
  1620. X  ToError(forward)
  1621. X  {
  1622. X      do {
  1623. X!         toerror(forward);
  1624. X!         exp = 1;
  1625. X      } while (!okay_error());
  1626. X      ShowErr();
  1627. X  }
  1628. X--- 185,191 ----
  1629. X  ToError(forward)
  1630. X  {
  1631. X      do {
  1632. X!         toerror(forward, arg_value());
  1633. X      } while (!okay_error());
  1634. X      ShowErr();
  1635. X  }
  1636. X***************
  1637. X*** 293,303 ****
  1638. X         default command and let the person decide. */
  1639. X  
  1640. X      compilation = (sindex("make", make_cmd) || sindex("cc", make_cmd));
  1641. X!     if (exp_p || !compilation) {
  1642. X          if (!compilation) {
  1643. X              rbell();
  1644. X!             Inputp = make_cmd;    /* insert the default for the
  1645. X!                            user */
  1646. X          }
  1647. X          null_ncpy(make_cmd, ask(make_cmd, "Compilation command: "),
  1648. X                  sizeof (make_cmd) - 1);
  1649. X--- 290,299 ----
  1650. X         default command and let the person decide. */
  1651. X  
  1652. X      compilation = (sindex("make", make_cmd) || sindex("cc", make_cmd));
  1653. X!     if (is_an_arg() || !compilation) {
  1654. X          if (!compilation) {
  1655. X              rbell();
  1656. X!             Inputp = make_cmd;    /* insert the default for the user */
  1657. X          }
  1658. X          null_ncpy(make_cmd, ask(make_cmd, "Compilation command: "),
  1659. X                  sizeof (make_cmd) - 1);
  1660. X***************
  1661. X*** 367,373 ****
  1662. X                        curline, curchar);
  1663. X          }
  1664. X          SetBuf(wordsb);
  1665. X!         line_move(FORWARD, NO);
  1666. X      }
  1667. X      add_mess("Done.");
  1668. X      SetBuf(buftospel);
  1669. X--- 363,369 ----
  1670. X                        curline, curchar);
  1671. X          }
  1672. X          SetBuf(wordsb);
  1673. X!         line_move(FORWARD, 1, NO);
  1674. X      }
  1675. X      add_mess("Done.");
  1676. X      SetBuf(buftospel);
  1677. X***************
  1678. X*** 378,387 ****
  1679. X  
  1680. X  ShToBuf()
  1681. X  {
  1682. X!     char    bufname[100];
  1683. X  
  1684. X      strcpy(bufname, ask((char *) 0, "Buffer: "));
  1685. X!     DoShell(bufname, ask(ShcomBuf, "Command: "));
  1686. X  }
  1687. X  
  1688. X  ShellCom()
  1689. X--- 374,385 ----
  1690. X  
  1691. X  ShToBuf()
  1692. X  {
  1693. X!     char    bufname[128],
  1694. X!         cmd[128];
  1695. X  
  1696. X      strcpy(bufname, ask((char *) 0, "Buffer: "));
  1697. X!     strcpy(cmd, ask(ShcomBuf, "Command: "));
  1698. X!     DoShell(bufname, cmd);
  1699. X  }
  1700. X  
  1701. X  ShellCom()
  1702. X***************
  1703. X*** 402,409 ****
  1704. X      Window    *savewp = curwind;
  1705. X      int    status;
  1706. X  
  1707. X!     exp = 1;
  1708. X!     status = UnixToBuf(bufname, YES, 0, !exp_p, Shell,
  1709. X                 ShFlags, command, (char *) 0);
  1710. X      com_finish(status, command);
  1711. X      SetWind(savewp);
  1712. X--- 400,406 ----
  1713. X      Window    *savewp = curwind;
  1714. X      int    status;
  1715. X  
  1716. X!     status = UnixToBuf(bufname, YES, 0, !is_an_arg(), Shell,
  1717. X                 ShFlags, command, (char *) 0);
  1718. X      com_finish(status, command);
  1719. X      SetWind(savewp);
  1720. X***************
  1721. X*** 465,471 ****
  1722. X     to fix everything up after we're done.  (Usually there's nothing to
  1723. X     fix up.) */
  1724. X  
  1725. X! /* VARARGS5 */
  1726. X  
  1727. X  UnixToBuf(bufname, disp, wsize, clobber, va_alist)
  1728. X  char    *bufname;
  1729. X--- 462,468 ----
  1730. X     to fix everything up after we're done.  (Usually there's nothing to
  1731. X     fix up.) */
  1732. X  
  1733. X! /* VARARGS4 */
  1734. X  
  1735. X  UnixToBuf(bufname, disp, wsize, clobber, va_alist)
  1736. X  char    *bufname;
  1737. X***************
  1738. X*** 517,523 ****
  1739. X  #else
  1740. X      old_int = signal(SIGINT, SIG_IGN),
  1741. X  #endif
  1742. X-     exp = 1;
  1743. X      dopipe(p);
  1744. X      pid = fork();
  1745. X      if (pid == -1) {
  1746. X--- 514,519 ----
  1747. X***************
  1748. X*** 621,633 ****
  1749. X  {
  1750. X      Mark    *m = CurMark();
  1751. X      char    *tname = mktemp("/tmp/jfilterXXXXXX"),
  1752. X!         combuf[130];
  1753. X      Window    *save_wind = curwind;
  1754. X!     int    status;
  1755. X      File    *fp;
  1756. X  
  1757. X-     CATCH
  1758. X      fp = open_file(tname, iobuff, F_WRITE, COMPLAIN, QUIET);
  1759. X      putreg(fp, m->m_line, m->m_char, curline, curchar, YES);
  1760. X      DelReg();
  1761. X      sprintf(combuf, "%s < %s", cmd, tname);
  1762. X--- 617,630 ----
  1763. X  {
  1764. X      Mark    *m = CurMark();
  1765. X      char    *tname = mktemp("/tmp/jfilterXXXXXX"),
  1766. X!         combuf[128];
  1767. X      Window    *save_wind = curwind;
  1768. X!     int    status,
  1769. X!         error = NO;
  1770. X      File    *fp;
  1771. X  
  1772. X      fp = open_file(tname, iobuff, F_WRITE, COMPLAIN, QUIET);
  1773. X+     CATCH
  1774. X      putreg(fp, m->m_line, m->m_char, curline, curchar, YES);
  1775. X      DelReg();
  1776. X      sprintf(combuf, "%s < %s", cmd, tname);
  1777. X***************
  1778. X*** 634,646 ****
  1779. X      status = UnixToBuf(outbuf->b_name, NO, 0, outbuf->b_type == B_SCRATCH,
  1780. X                 Shell, ShFlags, combuf, (char *) 0);
  1781. X      ONERROR
  1782. X!     ;    /* Do nothing ... but fall through and delete the tmp
  1783. X!            file. */
  1784. X      ENDCATCH
  1785. X      f_close(fp);
  1786. X      (void) unlink(tname);
  1787. X      SetWind(save_wind);
  1788. X!     com_finish(status, combuf);
  1789. X  }
  1790. X  
  1791. X  isprocbuf(bufname)
  1792. X--- 631,643 ----
  1793. X      status = UnixToBuf(outbuf->b_name, NO, 0, outbuf->b_type == B_SCRATCH,
  1794. X                 Shell, ShFlags, combuf, (char *) 0);
  1795. X      ONERROR
  1796. X!     error = YES;
  1797. X      ENDCATCH
  1798. X      f_close(fp);
  1799. X      (void) unlink(tname);
  1800. X      SetWind(save_wind);
  1801. X!     if (error == NO)
  1802. X!         com_finish(status, combuf);
  1803. X  }
  1804. X  
  1805. X  isprocbuf(bufname)
  1806. XOnly in ojove: rcs.output
  1807. Xdiff -c ojove/re.c jove/re.c
  1808. X*** ojove/re.c    Thu Jul 16 09:14:53 1987
  1809. X--- jove/re.c    Wed Jun 24 12:43:25 1987
  1810. X***************
  1811. X*** 26,50 ****
  1812. X      WrapScan = 0,
  1813. X      UseRE = 0;
  1814. X  
  1815. X- private char    CaseEquiv[] = {
  1816. X-     '\000',    '\001',    '\002',    '\003',    '\004',    '\005',    '\006',    '\007',
  1817. X-     '\010',    '\011',    '\012',    '\013',    '\014',    '\015',    '\016',    '\017',
  1818. X-     '\020',    '\021',    '\022',    '\023',    '\024',    '\025',    '\026',    '\027',
  1819. X-     '\030',    '\031',    '\032',    '\033',    '\034',    '\035',    '\036',    '\037',
  1820. X-     '\040',    '!',    '"',    '#',    '$',    '%',    '&',    '\'',
  1821. X-     '(',    ')',    '*',    '+',    ',',    '-',    '.',    '/',
  1822. X-     '0',    '1',    '2',    '3',    '4',    '5',    '6',    '7',
  1823. X-     '8',    '9',    ':',    ';',    '<',    '=',    '>',    '?',
  1824. X-     '@',    'A',    'B',    'C',    'D',    'E',    'F',    'G',
  1825. X-     'H',    'I',    'J',    'K',    'L',    'M',    'N',    'O',
  1826. X-     'P',    'Q',    'R',    'S',    'T',    'U',    'V',    'W',
  1827. X-     'X',    'Y',    'Z',    '[',    '\\',    ']',    '^',    '_',
  1828. X-     '`',    'A',    'B',    'C',    'D',    'E',    'F',    'G',
  1829. X-     'H',    'I',    'J',    'K',    'L',    'M',    'N',    'O',
  1830. X-     'P',    'Q',    'R',    'S',    'T',    'U',    'V',    'W',
  1831. X-     'X',    'Y',    'Z',    '{',    '|',    '}',    '~',    '\177'
  1832. X- };
  1833. X- 
  1834. X  #define cind_cmp(a, b)    (CaseEquiv[a] == CaseEquiv[b])
  1835. X  
  1836. X  private int    REpeekc;
  1837. X--- 26,31 ----
  1838. X***************
  1839. X*** 738,747 ****
  1840. X  
  1841. X      if (!delp) while (c = *repp++) {
  1842. X          if (c == '\\') {
  1843. X!             if ((c = *repp++) == '\0') {
  1844. X                  *tp++ = '\\';
  1845. X                    goto endchk;
  1846. X!             } else if ((c = *repp++) >= '1' && c <= nparens + '1') {
  1847. X                  tp = insert(tp, endp, c - '1');
  1848. X                  continue;
  1849. X              }
  1850. X--- 719,729 ----
  1851. X  
  1852. X      if (!delp) while (c = *repp++) {
  1853. X          if (c == '\\') {
  1854. X!             c = *repp++;
  1855. X!             if (c == '\0') {
  1856. X                  *tp++ = '\\';
  1857. X                    goto endchk;
  1858. X!             } else if (c >= '1' && c <= nparens + '1') {
  1859. X                  tp = insert(tp, endp, c - '1');
  1860. X                  continue;
  1861. X              }
  1862. X***************
  1863. X*** 786,792 ****
  1864. X          repbuf[sizeof rep_str],
  1865. X          *altbuf[NALTS];
  1866. X      int    npars;
  1867. X!     Mark    *m = MakeMark(curline, REbom, FLOATER);
  1868. X  
  1869. X      message("Type C-X C-C to continue with query replace.");
  1870. X  
  1871. X--- 768,774 ----
  1872. X          repbuf[sizeof rep_str],
  1873. X          *altbuf[NALTS];
  1874. X      int    npars;
  1875. X!     Mark    *m = MakeMark(curline, REbom, M_FLOATER);
  1876. X  
  1877. X      message("Type C-X C-C to continue with query replace.");
  1878. X  
  1879. X***************
  1880. X*** 801,807 ****
  1881. X      byte_copy(sbuf, searchstr, sizeof searchstr);
  1882. X      byte_copy(repbuf, rep_str, sizeof rep_str);
  1883. X      byte_copy((char *) altbuf, (char *) alternates, sizeof alternates);
  1884. X!     if (!exp_p)
  1885. X          ToMark(m);
  1886. X      DelMark(m);
  1887. X  }
  1888. X--- 783,789 ----
  1889. X      byte_copy(sbuf, searchstr, sizeof searchstr);
  1890. X      byte_copy(repbuf, rep_str, sizeof rep_str);
  1891. X      byte_copy((char *) altbuf, (char *) alternates, sizeof alternates);
  1892. X!     if (!is_an_arg())
  1893. X          ToMark(m);
  1894. X      DelMark(m);
  1895. X  }
  1896. Xdiff -c ojove/re1.c jove/re1.c
  1897. X*** ojove/re1.c    Thu Jul 16 09:14:58 1987
  1898. X--- jove/re1.c    Fri Jul 10 09:25:51 1987
  1899. X***************
  1900. X*** 8,15 ****
  1901. X  #include "jove.h"
  1902. X  #include "io.h"
  1903. X  #include "re.h"
  1904. X  
  1905. X! static
  1906. X  substitute(query, l1, char1, l2, char2)
  1907. X  Line    *l1,
  1908. X      *l2;
  1909. X--- 8,17 ----
  1910. X  #include "jove.h"
  1911. X  #include "io.h"
  1912. X  #include "re.h"
  1913. X+ #include <sys/types.h>
  1914. X+ #include <sys/stat.h>
  1915. X  
  1916. X! private
  1917. X  substitute(query, l1, char1, l2, char2)
  1918. X  Line    *l1,
  1919. X      *l2;
  1920. X***************
  1921. X*** 35,41 ****
  1922. X              if (query) {
  1923. X                  message("Replace (Type '?' for help)? ");
  1924. X  reswitch:            redisplay();
  1925. X!                 switch (Upper(getchar())) {
  1926. X                  case '.':
  1927. X                      stop++;
  1928. X                      /* Fall into ... */
  1929. X--- 37,43 ----
  1930. X              if (query) {
  1931. X                  message("Replace (Type '?' for help)? ");
  1932. X  reswitch:            redisplay();
  1933. X!                 switch (CharUpcase(getchar())) {
  1934. X                  case '.':
  1935. X                      stop++;
  1936. X                      /* Fall into ... */
  1937. X***************
  1938. X*** 51,57 ****
  1939. X                          goto nxtline;
  1940. X                      continue;
  1941. X  
  1942. X!                 case CTL(W):
  1943. X                      re_dosub(linebuf, YES);
  1944. X                      numdone++;
  1945. X                      offset = curchar = REbom;
  1946. X--- 53,59 ----
  1947. X                          goto nxtline;
  1948. X                      continue;
  1949. X  
  1950. X!                 case CTL('W'):
  1951. X                      re_dosub(linebuf, YES);
  1952. X                      numdone++;
  1953. X                      offset = curchar = REbom;
  1954. X***************
  1955. X*** 58,64 ****
  1956. X                      makedirty(curline);
  1957. X                      /* Fall into ... */
  1958. X  
  1959. X!                 case CTL(R):
  1960. X                  case 'R':
  1961. X                      RErecur();
  1962. X                      offset = curchar;
  1963. X--- 60,66 ----
  1964. X                      makedirty(curline);
  1965. X                      /* Fall into ... */
  1966. X  
  1967. X!                 case CTL('R'):
  1968. X                  case 'R':
  1969. X                      RErecur();
  1970. X                      offset = curchar;
  1971. X***************
  1972. X*** 65,71 ****
  1973. X                      lp = curline;
  1974. X                      continue;
  1975. X  
  1976. X!                 case CTL(U):
  1977. X                  case 'U':
  1978. X                      if (UNDO_lp == 0)
  1979. X                          continue;
  1980. X--- 67,73 ----
  1981. X                      lp = curline;
  1982. X                      continue;
  1983. X  
  1984. X!                 case CTL('U'):
  1985. X                  case 'U':
  1986. X                      if (UNDO_lp == 0)
  1987. X                          continue;
  1988. X***************
  1989. X*** 85,91 ****
  1990. X                  case 'Q':
  1991. X                      goto done;
  1992. X  
  1993. X!                 case CTL(L):
  1994. X                      RedrawDisplay();
  1995. X                      goto reswitch;
  1996. X  
  1997. X--- 87,93 ----
  1998. X                  case 'Q':
  1999. X                      goto done;
  2000. X  
  2001. X!                 case CTL('L'):
  2002. X                      RedrawDisplay();
  2003. X                      goto reswitch;
  2004. X  
  2005. X***************
  2006. X*** 110,116 ****
  2007. X  nxtline:            break;
  2008. X          }
  2009. X      }
  2010. X!     SetMark();
  2011. X  done:    s_mess("%d substitution%n.", numdone, numdone);
  2012. X  }
  2013. X  
  2014. X--- 112,118 ----
  2015. X  nxtline:            break;
  2016. X          }
  2017. X      }
  2018. X!     set_mark();
  2019. X  done:    s_mess("%d substitution%n.", numdone, numdone);
  2020. X  }
  2021. X  
  2022. X***************
  2023. X*** 117,126 ****
  2024. X  /* Prompt for search and replacement strings and do the substitution.  The
  2025. X     point is restored when we're done. */
  2026. X  
  2027. X! static
  2028. X  replace(query, inreg)
  2029. X  {
  2030. X!     Mark    *save = MakeMark(curline, curchar, FLOATER),
  2031. X          *m;
  2032. X      char    *rep_ptr;
  2033. X      Line    *l1 = curline,
  2034. X--- 119,128 ----
  2035. X  /* Prompt for search and replacement strings and do the substitution.  The
  2036. X     point is restored when we're done. */
  2037. X  
  2038. X! private
  2039. X  replace(query, inreg)
  2040. X  {
  2041. X!     Mark    *save = MakeMark(curline, curchar, M_FLOATER),
  2042. X          *m;
  2043. X      char    *rep_ptr;
  2044. X      Line    *l1 = curline,
  2045. X***************
  2046. X*** 166,174 ****
  2047. X      replace(0, NO);
  2048. X  }
  2049. X  
  2050. X! /* C tags package. */
  2051. X  
  2052. X! static
  2053. X  lookup(searchbuf, filebuf, tag, file)
  2054. X  char    *searchbuf,
  2055. X      *filebuf,
  2056. X--- 168,180 ----
  2057. X      replace(0, NO);
  2058. X  }
  2059. X  
  2060. X! /* Lookup a tag in tag file FILE.  FILE is assumed to be sorted
  2061. X!    alphabetically.  The FASTTAGS code, which is implemented with
  2062. X!    a binary search, depends on this assumption.  If it's not true
  2063. X!    it is possible to comment out the fast tag code (which is clearly
  2064. X!    labeled) and everything else will just work. */
  2065. X  
  2066. X! private
  2067. X  lookup(searchbuf, filebuf, tag, file)
  2068. X  char    *searchbuf,
  2069. X      *filebuf,
  2070. X***************
  2071. X*** 176,205 ****
  2072. X      *file;
  2073. X  {
  2074. X      register int    taglen = strlen(tag);
  2075. X!     char    line[128],
  2076. X!         pattern[100];
  2077. X!     File    *fp;
  2078. X  
  2079. X      fp = open_file(file, iobuff, F_READ, !COMPLAIN, QUIET);
  2080. X      if (fp == NIL)
  2081. X          return 0;
  2082. X!     sprintf(pattern, "^%s[^\t]*\t\\([^\t]*\\)\t[?/]\\(.*\\)[?/]$", tag);
  2083. X      while (f_gets(fp, line, sizeof line) != EOF) {
  2084. X!         if (line[0] != *tag || strncmp(tag, line, taglen) != 0)
  2085. X              continue;
  2086. X!         if (!LookingAt(pattern, line, 0)) {
  2087. X              complain("I thought I saw it!");
  2088. X              break;
  2089. X          } else {
  2090. X              putmatch(2, searchbuf, 100);
  2091. X!             putmatch(1, filebuf, 100);
  2092. X!             close_file(fp);
  2093. X!             return 1;
  2094. X          }
  2095. X      }
  2096. X!     f_close(fp);
  2097. X!     s_mess("Can't find tag \"%s\".", tag);
  2098. X!     return 0;
  2099. X  }
  2100. X  
  2101. X  char    TagFile[128] = "./tags";
  2102. X--- 182,267 ----
  2103. X      *file;
  2104. X  {
  2105. X      register int    taglen = strlen(tag);
  2106. X!     char    line[BUFSIZ],
  2107. X!         pattern[128];
  2108. X!     register File    *fp;
  2109. X!     struct stat    stbuf;
  2110. X!     int    fast = YES,
  2111. X!         success = NO;
  2112. X!     register off_t    lower, upper;
  2113. X  
  2114. X+     sprintf(pattern, "^%s[^\t]*\t*\\([^\t]*\\)\t*[?/]\\([^?/]*\\)[?/]", tag);
  2115. X      fp = open_file(file, iobuff, F_READ, !COMPLAIN, QUIET);
  2116. X      if (fp == NIL)
  2117. X          return 0;
  2118. X! 
  2119. X!     /* ********BEGIN FAST TAG CODE******** */
  2120. X! 
  2121. X!     if (stat(file, &stbuf) < 0)
  2122. X!         fast = NO;
  2123. X!     else {
  2124. X!         lower = 0;
  2125. X!         upper = stbuf.st_size;
  2126. X!         if (upper - lower < BUFSIZ)
  2127. X!             fast = NO;
  2128. X!     }
  2129. X!     if (fast == YES) for (;;) {
  2130. X!         off_t    mid;
  2131. X!         int    whichway;
  2132. X! 
  2133. X!         if (upper - lower < BUFSIZ) {
  2134. X!             f_seek(fp, lower);
  2135. X!             break;            /* stop this nonsense */
  2136. X!         }
  2137. X!         mid = (lower + upper) / 2;
  2138. X!         f_seek(fp, mid);
  2139. X!         f_toNL(fp);
  2140. X!         if (f_gets(fp, line, sizeof line) == EOF)
  2141. X!             break;
  2142. X!         whichway = strncmp(line, tag, taglen);
  2143. X!         if (whichway < 0) {
  2144. X!             lower = mid;
  2145. X!             continue;
  2146. X!         } else if (whichway > 0) {
  2147. X!             upper = mid;
  2148. X!             continue;
  2149. X!         } else {
  2150. X!             if (strcmp(tag, line) == 0)    /* exact match */
  2151. X!                 goto found;
  2152. X!             goto look_harder;
  2153. X!         }
  2154. X!     }
  2155. X!     f_toNL(fp);
  2156. X!     /* END FAST TAG CODE */
  2157. X! 
  2158. X      while (f_gets(fp, line, sizeof line) != EOF) {
  2159. X!         int    cmp;
  2160. X! 
  2161. X! look_harder:    if (line[0] > *tag)
  2162. X!             break;
  2163. X!         else if ((cmp = strncmp(line, tag, taglen)) > 0)
  2164. X!             break;
  2165. X!         else if (cmp < 0)
  2166. X              continue;
  2167. X!         /* if we get here, we've found the match */
  2168. X! found:        if (!LookingAt(pattern, line, 0)) {
  2169. X              complain("I thought I saw it!");
  2170. X              break;
  2171. X          } else {
  2172. X+             putmatch(1, filebuf, FILESIZE);
  2173. X              putmatch(2, searchbuf, 100);
  2174. X!             success = YES;
  2175. X!             if (strcmp(tag, line) == 0)    /* exact match */
  2176. X!                 break;
  2177. X!             continue;
  2178. X          }
  2179. X      }
  2180. X!     close_file(fp);
  2181. X!         
  2182. X!     if (success == NO)
  2183. X!         s_mess("Can't find tag \"%s\".", tag);
  2184. X! 
  2185. X!     return success;
  2186. X  }
  2187. X  
  2188. X  char    TagFile[128] = "./tags";
  2189. X***************
  2190. X*** 223,235 ****
  2191. X          tagfname = TagFile;
  2192. X      if (lookup(sstr, filebuf, tag, tagfname) == 0)
  2193. X          return;
  2194. X!     SetMark();
  2195. X      b = do_find(curwind, filebuf, 0);
  2196. X      if (curbuf != b)
  2197. X          SetABuf(curbuf);
  2198. X      SetBuf(b);
  2199. X      if ((bp = dosearch(sstr, BACKWARD, 0)) == 0 &&
  2200. X!         (WrapScan || ((bp = dosearch(sstr, FORWARD, 0)) == 0)))
  2201. X          message("Well, I found the file, but the tag is missing.");
  2202. X      else
  2203. X          SetDot(bp);
  2204. X--- 285,297 ----
  2205. X          tagfname = TagFile;
  2206. X      if (lookup(sstr, filebuf, tag, tagfname) == 0)
  2207. X          return;
  2208. X!     set_mark();
  2209. X      b = do_find(curwind, filebuf, 0);
  2210. X      if (curbuf != b)
  2211. X          SetABuf(curbuf);
  2212. X      SetBuf(b);
  2213. X      if ((bp = dosearch(sstr, BACKWARD, 0)) == 0 &&
  2214. X!         ((bp = dosearch(sstr, FORWARD, 0)) == 0))
  2215. X          message("Well, I found the file, but the tag is missing.");
  2216. X      else
  2217. X          SetDot(bp);
  2218. X***************
  2219. X*** 237,243 ****
  2220. X  
  2221. X  FindTag()
  2222. X  {
  2223. X!     int    localp = !exp_p;
  2224. X      char    tag[128];
  2225. X  
  2226. X      strcpy(tag, ask((char *) 0, ProcFmt));
  2227. X--- 299,305 ----
  2228. X  
  2229. X  FindTag()
  2230. X  {
  2231. X!     int    localp = !is_an_arg();
  2232. X      char    tag[128];
  2233. X  
  2234. X      strcpy(tag, ask((char *) 0, ProcFmt));
  2235. X***************
  2236. X*** 260,266 ****
  2237. X          c2++;
  2238. X  
  2239. X      null_ncpy(tagname, linebuf + c1, c2 - c1);
  2240. X!     find_tag(tagname, !exp_p);
  2241. X  }
  2242. X  
  2243. X  /* I-search returns a code saying what to do:
  2244. X--- 322,328 ----
  2245. X          c2++;
  2246. X  
  2247. X      null_ncpy(tagname, linebuf + c1, c2 - c1);
  2248. X!     find_tag(tagname, !is_an_arg());
  2249. X  }
  2250. X  
  2251. X  /* I-search returns a code saying what to do:
  2252. X***************
  2253. X*** 282,288 ****
  2254. X          *incp = 0;
  2255. X  int    SExitChar = CR;
  2256. X  
  2257. X! #define cmp_char(a, b)    ((a) == (b) || (CaseIgnore && (Upper(a) == Upper(b))))
  2258. X  
  2259. X  static Bufpos *
  2260. X  doisearch(dir, c, failing)
  2261. X--- 344,350 ----
  2262. X          *incp = 0;
  2263. X  int    SExitChar = CR;
  2264. X  
  2265. X! #define cmp_char(a, b)    ((a) == (b) || (CaseIgnore && (CharUpcase(a) == CharUpcase(b))))
  2266. X  
  2267. X  static Bufpos *
  2268. X  doisearch(dir, c, failing)
  2269. X***************
  2270. X*** 294,300 ****
  2271. X      Bufpos    *bp;
  2272. X      extern int    okay_wrap;
  2273. X  
  2274. X!     if (c == CTL(S) || c == CTL(R))
  2275. X          goto dosrch;
  2276. X  
  2277. X      if (failing)
  2278. X--- 356,362 ----
  2279. X      Bufpos    *bp;
  2280. X      extern int    okay_wrap;
  2281. X  
  2282. X!     if (c == CTL('S') || c == CTL('R'))
  2283. X          goto dosrch;
  2284. X  
  2285. X      if (failing)
  2286. X***************
  2287. X*** 338,344 ****
  2288. X          SetDot(&save_env);
  2289. X      else {
  2290. X          if (LineDist(curline, save_env.p_line) >= MarkThresh)
  2291. X!             DoSetMark(save_env.p_line, save_env.p_char);
  2292. X      }
  2293. X      setsearch(ISbuf);
  2294. X  }
  2295. X--- 400,406 ----
  2296. X          SetDot(&save_env);
  2297. X      else {
  2298. X          if (LineDist(curline, save_env.p_line) >= MarkThresh)
  2299. X!             do_set_mark(save_env.p_line, save_env.p_char);
  2300. X      }
  2301. X      setsearch(ISbuf);
  2302. X  }
  2303. X***************
  2304. X*** 385,391 ****
  2305. X          case BS:
  2306. X              return DELETE;
  2307. X  
  2308. X!         case CTL(G):
  2309. X              /* If we're failing, we backup until we're no longer
  2310. X                 failing or we've reached the beginning; else, we
  2311. X                 just about the search and go back to the start. */
  2312. X--- 447,453 ----
  2313. X          case BS:
  2314. X              return DELETE;
  2315. X  
  2316. X!         case CTL('G'):
  2317. X              /* If we're failing, we backup until we're no longer
  2318. X                 failing or we've reached the beginning; else, we
  2319. X                 just about the search and go back to the start. */
  2320. X***************
  2321. X*** 393,402 ****
  2322. X                  return BACKUP;
  2323. X              return TOSTART;
  2324. X  
  2325. X!         case CTL(\\):
  2326. X!             c = CTL(S);
  2327. X!         case CTL(S):
  2328. X!         case CTL(R):
  2329. X              /* If this is the first time through and we have a
  2330. X                 search string left over from last time, use that
  2331. X                 one now. */
  2332. X--- 455,464 ----
  2333. X                  return BACKUP;
  2334. X              return TOSTART;
  2335. X  
  2336. X!         case CTL('\\'):
  2337. X!             c = CTL('S');
  2338. X!         case CTL('S'):
  2339. X!         case CTL('R'):
  2340. X              /* If this is the first time through and we have a
  2341. X                 search string left over from last time, use that
  2342. X                 one now. */
  2343. X***************
  2344. X*** 404,410 ****
  2345. X                  strcpy(ISbuf, getsearch());
  2346. X                  incp = &ISbuf[strlen(ISbuf)];
  2347. X              }
  2348. X!             ndir = (c == CTL(S)) ? FORWARD : BACKWARD;
  2349. X              /* If we're failing and we're not changing our
  2350. X                 direction, don't recur since there's no way
  2351. X                 the search can work. */
  2352. X--- 466,472 ----
  2353. X                  strcpy(ISbuf, getsearch());
  2354. X                  incp = &ISbuf[strlen(ISbuf)];
  2355. X              }
  2356. X!             ndir = (c == CTL('S')) ? FORWARD : BACKWARD;
  2357. X              /* If we're failing and we're not changing our
  2358. X                 direction, don't recur since there's no way
  2359. X                 the search can work. */
  2360. X***************
  2361. X*** 423,430 ****
  2362. X              add_mess("\\");
  2363. X              /* Fall into ... */
  2364. X  
  2365. X!         case CTL(Q):
  2366. X!         case CTL(^):
  2367. X              add_mess("");
  2368. X              c = getch() | 0400;
  2369. X              /* Fall into ... */
  2370. X--- 485,492 ----
  2371. X              add_mess("\\");
  2372. X              /* Fall into ... */
  2373. X  
  2374. X!         case CTL('Q'):
  2375. X!         case CTL('^'):
  2376. X              add_mess("");
  2377. X              c = getch() | 0400;
  2378. X              /* Fall into ... */
  2379. END_OF_FILE
  2380. if test 50121 -ne `wc -c <'jove.pch.3'`; then
  2381.     echo shar: \"'jove.pch.3'\" unpacked with wrong size!
  2382. fi
  2383. # end of 'jove.pch.3'
  2384. fi
  2385. echo shar: End of archive 3 \(of 4\).
  2386. cp /dev/null ark3isdone
  2387. MISSING=""
  2388. for I in 1 2 3 4 ; do
  2389.     if test ! -f ark${I}isdone ; then
  2390.     MISSING="${MISSING} ${I}"
  2391.     fi
  2392. done
  2393. if test "${MISSING}" = "" ; then
  2394.     echo You have unpacked all 4 archives.
  2395.     rm -f ark[1-9]isdone
  2396. else
  2397.     echo You still need to unpack the following archives:
  2398.     echo "        " ${MISSING}
  2399. fi
  2400. ##  End of shell archive.
  2401. exit 0
  2402.